Type-Inference Based Short Cut Deforestation (nearly) without Inlining

Deforestation optimises a functional program by transforming it into another one that does not create certain intermediate data structures. In [ICFP'99] we presented a type-inference based deforestation algorithm which performs extensive inlining. However, across module boundaries only limited inlining is practically feasible. Furthermore, inlining is a non-trivial transformation which is therefore best implemented as a separate optimisation pass. To perform short cut deforestation (nearly) without inlining, Gill suggested to split definitions into workers and wrappers and inline only the small wrappers, which transfer the information needed for deforestation. We show that Gill's use of a function build limits deforestation and note that his reasons for using build do not apply to our approach. Hence we develop a more general worker/wrapper scheme without build. We give a type-inference based algorithm which splits definitions into workers and wrappers. Finally, we show that we can deforest more expressions with the worker/wrapper scheme than the algorithm with inlining

Improving the compilation of prolog to C using moded types and determinism information

We describe the current status of and provide performance results for a prototype compiler of Prolog to C, ciaocc. ciaocc is novel in that it is designed to accept different kinds of high-level information, typically obtained via an automatic analysis of the initial Prolog program and expressed in a standardized language of assertions. This information is used to optimize the resulting C code, which is then processed by an off-the-shelf C compiler. The basic translation process essentially mimics the unfolding of a bytecode emulator with respect to the particular bytecode corresponding to the Prolog program. This is facilitated by a flexible design of the instructions and their lower-level components. This approach allows reusing a sizable amount of the machinery of the bytecode emulator: predicates already written in C, data definitions, memory management routines and áreas, etc., as well as mixing emulated bytecode with native code in a relatively straightforward way. We report on the performance of programs compiled by the current versión of the system, both with and without analysis information

A Functional Shell that Dynamically Combines Compiled Code

Contains fulltext : 60594.pdf (author's version ) (Open Access)We present a new shell that provides the full basic functionality of a strongly typed lazy functional language, including overloading. The shell can be used for manipulating files, applications, data and processes at the command line. The shell does type checking and only executes well-typed expressions. Files are typed, and applications are simply files with a function type. The shell executes a command line by combining existing code of functions on disk. We use the hybrid static/dynamic type system of Clean to do type checking/inference. Its dynamic linker is used to store and retrieve any expression (both data and code) with its type on disk. Our shell combines the advantages of interpreters (direct response) and compilers (statically typed, fast code). Applications (compiled functions) can be used, in a type safe way, in the shell, and functions defined in the shell can be used by any compiled application.IFL 200

Fluoro-Gold (FG) retrograde tracing.

<p>Micrographs of FG-labeled motoneurons in spinal cord (transverse sections: A1, B1, C1, and D1; longitudinal sections: A2, B2, C2, and D2) and sensory neurons in dorsal root ganglions (transverse sections: A3, B3, C3, and D3) in the autograft group (A1–A3), NGF–CMSs/CCH group (B1–B3), NGF/CCH group (C1–C3), and CCH group (D1–D3) at 16 weeks after nerve-bridging operation. The total number of FG-labeled motoneurons and sensory neurons in each group were shown in (E) and (F). All data represent mean ± SD. *<i>p</i><0.05 between autograft and others (CCH, NGF/CCH, and NGF–CMSs/CCH). ^#<i>p</i><0.05 between NGF–CMSs/CCH and others (CCH and NGF/CCH). ^&<i>p</i><0.05 between NGF/CCH and CCH. Scale bar = 100 µm.</p

Inductive families need not store their indices

Abstract. We consider the problem of efficient representation of dependently typed data. In particular, we consider a language TT based on Dybjer&apos;s notion of inductive families [11] and reanalyse their general form with a view to optimising the storage associated with their use. We introduce an execution language, ExTT, which allows the commenting out of computationally irrelevant subterms and show how to use properties of elimination rules to elide constructor arguments and tags in ExTT. We further show how some types can be collapsed entirely at run-time. Several examples are given, including a representation of the simply typed *-calculus for which our analysis yields an 80 % reduction in run-time storage requirements. 1 Introduction Dependent type theory provides programmers with more than an integrated logic for reasoning about program correctness. It allows more precise types for programs and data in the first place, strengthening the typechecker&apos;s language of guarantees. We have richer function types 8x: S: T which adapt their return types to each argument; we also have richer data structures which do not just contain but explain data, exposing and enforcing their properties. Moreover, we may reasonably expect more static detail about programs and data to yield better optimised dynamic behaviour. We need neither test what is guaranteed nor store what is determined by typechecking. Pollack&apos;s implicit syntax [24] already supports the omission of much redundant information from concrete syntax for similar reasons

Ausbau eines automatischen Optimierungsprozesses für die Verdichterauslegung um dynamische Analysen mit der Methode der Finiten Elemente

Im Deutschen Zentrum für Luft- und Raumfahrt (DLR) wird ein automatisch arbeitender evolutionärer Optimierer für die aerodynamische Verdichterauslegung eingesetzt. In diesem komplexen Prozess wird ein optimaler Kompromiss zwischen unterschiedlichen Anforderungen gesucht, auf die simultan optimiert wird (Mehrziel-Optimierung). Diese Anforderungen können beliebig aus dem Analyseteil des Optimierungskreislaufs gewählt werden. Der Analyseteil für die Zielfunktion ist modular aufgebaut und wird permanent erweitert und verbessert. Im Rahmen der Diplomarbeit wird er durch eine strukturmechanische Analyse erweitert. Folgende Aufgaben werden hierfür bearbeitet: - Definition der notwendigen Steuerparameter für den Analyseprozess; - C-Programmierung eines automatisierten "Pre-Processings" (Modifikation der Schaufelblattgeometrie anhand strukturmechanischer Erfordernisse, insbesondere Hot-to-Cold-Transformation); - C-Programmierung eines automatisierten "Post-Processings" (Analyse) der Resultate der Finite-Elemente-Simulation (FE-Simulation); - Einbettung in die Gesamtprozesskette; - Formulierung von strukturmechanisch relevanten Zielfunktionen; - Durchführung einer Strukturoptimierung anhand eines Beispiel-Rotorblattes. Ziel dieser Arbeit ist eine funktionsfähige und dokumentierte Prozesskette, die eine Optimierung der strukturmechanischen Eigenschaften eines Schaufelblattes ermöglicht. Dies ist ein weiterer Schritt zur Realisierung einer multidisziplinären Optimierung von Verdichtern

Interprocedural Analysis with Lazy Propagation

Abstract. We propose lazy propagation as a technique for flow- and context-sensitive interprocedural analysis of programs with objects and first-class functions where transfer functions may not be distributive. The technique is described formally as a systematic modification of a variant of the monotone framework and its theoretical properties are shown. It is implemented in a type analysis tool for JavaScript where it results in a significant improvement in performance.